package 集合;

//Vector 可实现自动增长的对象数组。 
//java.util.vector提供了向量类(Vector)以实现类似动态数组的功能。 
//创建了一个向量类的对象后，可以往其中随意插入不同类的对象，即不需顾及类型也不需预先选定向量的容量，并可以方便地进行查找。
//对于预先不知或者不愿预先定义数组大小，并且需要频繁地进行查找，插入，删除工作的情况，可以考虑使用向量类。

//Vector 类实现了一个动态数组。和 ArrayList 很相似，但是两者是不同的：
//-Vector 是同步访问的。
//-Vector 包含了许多传统的方法，这些方法不属于集合框架。
//
//Vector 主要用在事先不知道数组的大小，或者只是需要一个可以改变大小的数组的情况。
//
//Vector 类支持 4 种构造方法。

//public vector()//创建一个默认的向量，默认大小为 10
//public vector(int initialcapacity,int capacityIncrement)//capacity是Vector的默认容量大小，capacityIncrement是每次Vector容量增加时的增量值。 
//public vector(int initialcapacity)//capacity是Vector的默认容量大小。当由于增加数据导致容量增加时，每次容量会增加一倍。
//public Vector(Collection c) // 创建一个包含collection的Vector

//除了从父类继承的方法外 Vector 还定义了以下方法：
//
//序号	                                                      方法描述
//1	void add(int index, Object element) 在此向量的指定位置插入指定的元素。
//2	boolean add(Object o) 将指定元素添加到此向量的末尾。
//3	boolean addAll(Collection c)  将指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的顺序添加这些元素。
//4	boolean addAll(int index, Collection c) 在指定位置将指定 Collection 中的所有元素插入到此向量中。
//5	void addElement(Object obj) 将指定的组件添加到此向量的末尾，将其大小增加 1。
//6	int capacity()  返回此向量的当前容量。
//7	void clear()    从此向量中移除所有元素。
//8	Object clone()  返回向量的一个副本。
//9	boolean contains(Object elem)     如果此向量包含指定的元素，则返回 true。
//10 boolean containsAll(Collection c) 如果此向量包含指定 Collection 中的所有元素，则返回 true。
//11 void copyInto(Object[] anArray)   将此向量的组件复制到指定的数组中。
//12 Object elementAt(int index)       返回指定索引处的组件。
//13 Enumeration elements()            返回此向量的组件的枚举。
//14 void ensureCapacity(int minCapacity) 增加此向量的容量（如有必要），以确保其至少能够保存最小容量参数指定的组件数。
//15 boolean equals(Object o)          比较指定对象与此向量的相等性。
//16 Object firstElement()             返回此向量的第一个组件（位于索引 0) 处的项）。
//17 Object get(int index)             返回向量中指定位置的元素。
//18 int hashCode()                    返回此向量的哈希码值。
//19 int indexOf(Object elem)          返回此向量中第一次出现的指定元素的索引，如果此向量不包含该元素，则返回 -1。
//20 int indexOf(Object elem, int index) 返回此向量中第一次出现的指定元素的索引，从 index 处正向搜索，如果未找到该元素，则返回 -1。
//21 void insertElementAt(Object obj, int index) 将指定对象作为此向量中的组件插入到指定的 index 处。
//22 boolean isEmpty()                 测试此向量是否不包含组件。
//23 Object lastElement()              返回此向量的最后一个组件。
//24 int lastIndexOf(Object elem)      返回此向量中最后一次出现的指定元素的索引；如果此向量不包含该元素，则返回 -1。
//25 int lastIndexOf(Object elem, int index) 返回此向量中最后一次出现的指定元素的索引，从 index 处逆向搜索，如果未找到该元素，则返回 -1。
//26 Object remove(int index)          移除此向量中指定位置的元素。
//27 boolean remove(Object o)          移除此向量中指定元素的第一个匹配项，如果向量不包含该元素，则元素保持不变。
//28 boolean removeAll(Collection c)   从此向量中移除包含在指定 Collection 中的所有元素。
//29 void removeAllElements()          从此向量中移除全部组件，并将其大小设置为零。
//30 boolean removeElement(Object obj) 从此向量中移除变量的第一个（索引最小的）匹配项。
//31 void removeElementAt(int index)   删除指定索引处的组件。
//32 protected void removeRange(int fromIndex, int toIndex) 从此 List 中移除其索引位于 fromIndex（包括）与 toIndex（不包括）之间的所素。
//33 boolean retainAll(Collection c)   在此向量中仅保留包含在指定 Collection 中的元素。
//34 Object set(int index, Object element) 用指定的元素替换此向量中指定位置处的元素。
//35 void setElementAt(Object obj, int index)  将此向量指定 index 处的组件设置为指定的对象。
//36 void setSize(int newSize)         设置此向量的大小。
//37 int size()                        返回此向量中的组件数。
//38 List subList(int fromIndex, int toIndex) 返回此 List 的部分视图，元素范围为从 fromIndex（包括）到 toIndex（不包括）。
//39 Object[] toArray()      返回一个数组，包含此向量中以恰当顺序存放的所有元素。
//40 Object[] toArray(Object[] a) 返回一个数组，包含此向量中以恰当顺序存放的所有元素；返回数组的运行时类型为指定数组的类型。
//41 String toString() 返回此向量的字符串表示形式，其中包含每个元素的 String 表示形式。
//42 void trimToSize()   对此向量的容量进行微调，使其等于向量的当前大小。
//
//实例
//下面的程序说明这个集合所支持的几种方法：
/*
import java.util.Vector;
public class 使用Vector {
   public static void main(String args[]) {
      // initial size is 3, increment is 2
      Vector<Number> v = new Vector<>(3, 2);//Vector(int size,int incr) 并且增量用incr指定。增量表示向量每次增加的元素数目。
      System.out.println("Initial size: " + v.size());//list.size()
      System.out.println("Initial capacity: " +
      v.capacity());//int capacity()  返回此向量的当前容量。
      v.addElement(Integer.valueOf(1));
      v.addElement(Integer.valueOf(2));
      v.addElement(Integer.valueOf(3));
      v.addElement(Integer.valueOf(4));
      System.out.println("Capacity after four additions: " +v.capacity());
      v.addElement(Double.valueOf(5.45));
      System.out.println("Current capacity: " +v.capacity());
      v.addElement(Double.valueOf(6.08));
      v.addElement(Integer.valueOf(7));
      System.out.println("Current capacity: " +v.capacity());
      v.addElement(Float.valueOf((float) 9.4));
      v.addElement(Integer.valueOf(10));
      System.out.println("Current capacity: " +v.capacity());
      v.addElement(Integer.valueOf(11));
      v.addElement(Integer.valueOf(12));
      System.out.println("First element: " +(Integer)v.firstElement());
      System.out.println("Last element: " +(Integer)v.lastElement());
      if(v.contains(Integer.valueOf(3)))
         System.out.println("Vector contains 3.");
      // enumerate the elements in the vector.
      Enumeration<Number> vEnum = v.elements();//Enumeration elements() 返回此向量的组件的枚举。
      System.out.println("\nElements in vector:");
      while(vEnum.hasMoreElements())
         System.out.print(vEnum.nextElement() + " ");
      System.out.println();
   }
}
*/
//以上实例编译运行结果如下：
//
//Initial size: 0
//Initial capacity: 3
//Capacity after four additions: 5
//Current capacity: 5
//Current capacity: 7
//Current capacity: 9
//First element: 1
//Last element: 12
//Vector contains 3.
//
//Elements in vector:
//1 2 3 4 5.45 6.08 7 9.4 10 11 12
//
//Vector的add方法，我们可以看到该方法用了synchronized来修饰，表示线程安全，所以性能比较低，自从集合框架出来之后，如我们的List集
//合、Set集合等，性能都高于Vector，这也是Vector基本不再用的原因
//
//Vector的数据结构和ArrayList差不多，它包含了3个成员变量：elementData , elementCount， capacityIncrement。
//
//(01) elementData 是"Object[]类型的数组"，它保存了添加到Vector中的元素。elementData是个动态数组，如果初始化Vector时，
//     没指定动态数组的>大小，则使用默认大小10。随着Vector中元素的增加，Vector的容量也会动态增长，capacityIncrement是与容
//     量增长相关的增长系数，具体的增长方式，请参考源码分析中的ensureCapacity()函数。
//(02) elementCount 是动态数组的实际大小。
//(03) capacityIncrement 是动态数组的增长系数。如果在创建Vector时，指定了capacityIncrement的大小；则，每次当Vector中动态数组容量
//     增加时>，增加的大小都是capacityIncrement。
//
//《vector源码解析》
//package java.util;

//public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
//
//   
//    // 保存Vector中数据的数组
//    protected Object[] elementData;
//
//    // 实际数据的数量
//    protected int elementCount;
//
//    // 容量增长系数
//    protected int capacityIncrement;
//
//    // Vector的序列版本号
//    private static final long serialVersionUID = -2767605614048989439L;
//
//    // Vector构造函数。默认容量是10。
//    public Vector() {
//        this(10);
//    }
//
//    // 指定Vector容量大小的构造函数
//    public Vector(int initialCapacity) {
//        this(initialCapacity, 0);
//    }
//
//    // 指定Vector"容量大小"和"增长系数"的构造函数
//    public Vector(int initialCapacity, int capacityIncrement) {
//        super();
//        if (initialCapacity < 0)
//            throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
//        // 新建一个数组，数组容量是initialCapacity
//        this.elementData = new Object[initialCapacity];
//        // 设置容量增长系数
//        this.capacityIncrement = capacityIncrement;
//    }
//
//    // 指定集合的Vector构造函数。
//    public Vector(Collection<? extends E> c) {
//        // 获取“集合(c)”的数组，并将其赋值给elementData
//        elementData = c.toArray();
//        // 设置数组长度
//        elementCount = elementData.length;
//        // c.toArray might (incorrectly) not return Object[] (see 6260652)
//        if (elementData.getClass() != Object[].class)
//            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
//    }
//
//    // 将数组Vector的全部元素都拷贝到数组anArray中
//    public synchronized void copyInto(Object[] anArray) {
//        System.arraycopy(elementData, 0, anArray, 0, elementCount);
//    }
//
//    // 将当前容量值设为 =实际元素个数
//    public synchronized void trimToSize() {
//        modCount++;
//        int oldCapacity = elementData.length;
//        if (elementCount < oldCapacity) {
//            elementData = Arrays.copyOf(elementData, elementCount);
//        }
//    }
//
//    // 确认“Vector容量”的帮助函数
//    private void ensureCapacityHelper(int minCapacity) {
//        int oldCapacity = elementData.length;
//        // 当Vector的容量不足以容纳当前的全部元素，增加容量大小。
//        // 若 容量增量系数>0(即capacityIncrement>0)，则将容量增大当capacityIncrement
//        // 否则，将容量增大一倍。
//        if (minCapacity > oldCapacity) {
//            Object[] oldData = elementData;
//            int newCapacity = (capacityIncrement > 0) ?
//                (oldCapacity + capacityIncrement) : (oldCapacity * 2);
//            if (newCapacity < minCapacity) {
//                newCapacity = minCapacity;
//            }
//            elementData = Arrays.copyOf(elementData, newCapacity);
//        }
//    }
//
//    // 确定Vector的容量。
//    public synchronized void ensureCapacity(int minCapacity) {
//        // 将Vector的改变统计数+1
//        modCount++;
//        ensureCapacityHelper(minCapacity);
//    }
//
//    // 设置容量值为 newSize
//    public synchronized void setSize(int newSize) {
//        modCount++;
//        if (newSize > elementCount) {
//            // 若 "newSize 大于 Vector容量"，则调整Vector的大小。
//            ensureCapacityHelper(newSize);
//        } else {
//            // 若 "newSize 小于/等于 Vector容量"，则将newSize位置开始的元素都设置为null
//            for (int i = newSize ; i < elementCount ; i++) {
//                elementData[i] = null;
//            }
//        }
//        elementCount = newSize;
//    }
//
//    // 返回“Vector的总的容量”
//    public synchronized int capacity() {
//        return elementData.length;
//    }
//
//    // 返回“Vector的实际大小”，即Vector中元素个数
//    public synchronized int size() {
//        return elementCount;
//    }
//
//    // 判断Vector是否为空
//    public synchronized boolean isEmpty() {
//        return elementCount == 0;
//    }
//
//    // 返回“Vector中全部元素对应的Enumeration”
//    public Enumeration<E> elements() {
//        // 通过匿名类实现Enumeration
//        return new Enumeration<E>() {
//            int count = 0;
//
//            // 是否存在下一个元素
//            public boolean hasMoreElements() {
//                return count < elementCount;
//            }
//
//            // 获取下一个元素
//            public E nextElement() {
//                synchronized (Vector.this) {
//                    if (count < elementCount) {
//                        return (E)elementData[count++];
//                    }
//                }
//                throw new NoSuchElementException("Vector Enumeration");
//            }
//        };
//    }
//
//    // 返回Vector中是否包含对象(o)
//    public boolean contains(Object o) {
//        return indexOf(o, 0) >= 0;
//    }
//
//
//    // 从index位置开始向后查找元素(o)。
//    // 若找到，则返回元素的索引值；否则，返回-1
//    public synchronized int indexOf(Object o, int index) {
//        if (o == null) {
//            // 若查找元素为null，则正向找出null元素，并返回它对应的序号
//            for (int i = index ; i < elementCount ; i++)
//            if (elementData[i]==null)
//                return i;
//        } else {
//            // 若查找元素不为null，则正向找出该元素，并返回它对应的序号
//            for (int i = index ; i < elementCount ; i++)
//            if (o.equals(elementData[i]))
//                return i;
//        }
//        return -1;
//    }
//
//    // 查找并返回元素(o)在Vector中的索引值
//    public int indexOf(Object o) {
//        return indexOf(o, 0);
//    }
//
//    // 从后向前查找元素(o)。并返回元素的索引
//    public synchronized int lastIndexOf(Object o) {
//        return lastIndexOf(o, elementCount-1);
//    }
//
//    // 从后向前查找元素(o)。开始位置是从前向后的第index个数；
//    // 若找到，则返回元素的“索引值”；否则，返回-1。
//    public synchronized int lastIndexOf(Object o, int index) {
//        if (index >= elementCount)
//            throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
//
//        if (o == null) {
//            // 若查找元素为null，则反向找出null元素，并返回它对应的序号
//            for (int i = index; i >= 0; i--)
//            if (elementData[i]==null)
//                return i;
//        } else {
//            // 若查找元素不为null，则反向找出该元素，并返回它对应的序号
//            for (int i = index; i >= 0; i--)
//            if (o.equals(elementData[i]))
//                return i;
//        }
//        return -1;
//    }
//
//    // 返回Vector中index位置的元素。
//    // 若index月结，则抛出异常
//    public synchronized E elementAt(int index) {
//        if (index >= elementCount) {
//            throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
//        }
//
//        return (E)elementData[index];
//    }
//
//    // 获取Vector中的第一个元素。
//    // 若失败，则抛出异常！
//    public synchronized E firstElement() {
//        if (elementCount == 0) {
//            throw new NoSuchElementException();
//        }
//        return (E)elementData[0];
//    }
//
//    // 获取Vector中的最后一个元素。
//    // 若失败，则抛出异常！
//    public synchronized E lastElement() {
//        if (elementCount == 0) {
//            throw new NoSuchElementException();
//        }
//        return (E)elementData[elementCount - 1];
//    }
//
//    // 设置index位置的元素值为obj
//    public synchronized void setElementAt(E obj, int index) {
//        if (index >= elementCount) {
//            throw new ArrayIndexOutOfBoundsException(index + " >= " +
//                                 elementCount);
//        }
//        elementData[index] = obj;
//    }
//
//    // 删除index位置的元素
//    public synchronized void removeElementAt(int index) {
//        modCount++;
//        if (index >= elementCount) {
//            throw new ArrayIndexOutOfBoundsException(index + " >= " +
//                                 elementCount);
//        } else if (index < 0) {
//            throw new ArrayIndexOutOfBoundsException(index);
//        }
//
//        int j = elementCount - index - 1;
//        if (j > 0) {
//            System.arraycopy(elementData, index + 1, elementData, index, j);
//        }
//        elementCount--;
//        elementData[elementCount] = null; /* to let gc do its work */
//    }
//
//    // 在index位置处插入元素(obj)
//    public synchronized void insertElementAt(E obj, int index) {
//        modCount++;
//        if (index > elementCount) {
//            throw new ArrayIndexOutOfBoundsException(index
//                                 + " > " + elementCount);
//        }
//        ensureCapacityHelper(elementCount + 1);
//        System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
//        elementData[index] = obj;
//        elementCount++;
//    }
//
//    // 将“元素obj”添加到Vector末尾
//    public synchronized void addElement(E obj) {
//        modCount++;
//        ensureCapacityHelper(elementCount + 1);
//        elementData[elementCount++] = obj;
//    }
//
//    // 在Vector中查找并删除元素obj。
//    // 成功的话，返回true；否则，返回false。
//    public synchronized boolean removeElement(Object obj) {
//        modCount++;
//        int i = indexOf(obj);
//        if (i >= 0) {
//            removeElementAt(i);
//            return true;
//        }
//        return false;
//    }
//
//    // 删除Vector中的全部元素
//    public synchronized void removeAllElements() {
//        modCount++;
//        // 将Vector中的全部元素设为null
//        for (int i = 0; i < elementCount; i++)
//            elementData[i] = null;
//
//        elementCount = 0;
//    }
//
//    // 克隆函数
//    public synchronized Object clone() {
//        try {
//            Vector<E> v = (Vector<E>) super.clone();
//            // 将当前Vector的全部元素拷贝到v中
//            v.elementData = Arrays.copyOf(elementData, elementCount);
//            v.modCount = 0;
//            return v;
//        } catch (CloneNotSupportedException e) {
//            // this shouldn't happen, since we are Cloneable
//            throw new InternalError();
//        }
//    }
//
//    // 返回Object数组
//    public synchronized Object[] toArray() {
//        return Arrays.copyOf(elementData, elementCount);
//    }
//
//    // 返回Vector的模板数组。所谓模板数组，即可以将T设为任意的数据类型
//    public synchronized <T> T[] toArray(T[] a) {
//        // 若数组a的大小 < Vector的元素个数；
//        // 则新建一个T[]数组，数组大小是“Vector的元素个数”，并将“Vector”全部拷贝到新数组中
//        if (a.length < elementCount)
//            return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
//
//        // 若数组a的大小 >= Vector的元素个数；
//        // 则将Vector的全部元素都拷贝到数组a中。
//    System.arraycopy(elementData, 0, a, 0, elementCount);
//
//        if (a.length > elementCount)
//            a[elementCount] = null;
//
//        return a;
//    }
//
//    // 获取index位置的元素
//    public synchronized E get(int index) {
//        if (index >= elementCount)
//            throw new ArrayIndexOutOfBoundsException(index);
//
//        return (E)elementData[index];
//    }
//
//    // 设置index位置的值为element。并返回index位置的原始值
//    public synchronized E set(int index, E element) {
//        if (index >= elementCount)
//            throw new ArrayIndexOutOfBoundsException(index);
//
//        Object oldValue = elementData[index];
//        elementData[index] = element;
//        return (E)oldValue;
//    }
//
//    // 将“元素e”添加到Vector最后。
//    public synchronized boolean add(E e) {
//        modCount++;
//        ensureCapacityHelper(elementCount + 1);
//        elementData[elementCount++] = e;
//        return true;
//    }
//
//    // 删除Vector中的元素o
//    public boolean remove(Object o) {
//        return removeElement(o);
//    }
//
//    // 在index位置添加元素element
//    public void add(int index, E element) {
//        insertElementAt(element, index);
//    }
//
//    // 删除index位置的元素，并返回index位置的原始值
//    public synchronized E remove(int index) {
//        modCount++;
//        if (index >= elementCount)
//            throw new ArrayIndexOutOfBoundsException(index);
//        Object oldValue = elementData[index];
//
//        int numMoved = elementCount - index - 1;
//        if (numMoved > 0)
//            System.arraycopy(elementData, index+1, elementData, index,
//                     numMoved);
//        elementData[--elementCount] = null; // Let gc do its work
//
//        return (E)oldValue;
//    }
//
//    // 清空Vector
//    public void clear() {
//        removeAllElements();
//    }
//
//    // 返回Vector是否包含集合c
//    public synchronized boolean containsAll(Collection<?> c) {
//        return super.containsAll(c);
//    }
//
//    // 将集合c添加到Vector中
//    public synchronized boolean addAll(Collection<? extends E> c) {
//        modCount++;
//        Object[] a = c.toArray();
//        int numNew = a.length;
//        ensureCapacityHelper(elementCount + numNew);
//        // 将集合c的全部元素拷贝到数组elementData中
//        System.arraycopy(a, 0, elementData, elementCount, numNew);
//        elementCount += numNew;
//        return numNew != 0;
//    }
//
//    // 删除集合c的全部元素
//    public synchronized boolean removeAll(Collection<?> c) {
//        return super.removeAll(c);
//    }
//
//    // 删除“非集合c中的元素”
//    public synchronized boolean retainAll(Collection<?> c)  {
//        return super.retainAll(c);
//    }
//
//    // 从index位置开始，将集合c添加到Vector中
//    public synchronized boolean addAll(int index, Collection<? extends E> c) {
//        modCount++;
//        if (index < 0 || index > elementCount)
//            throw new ArrayIndexOutOfBoundsException(index);
//
//        Object[] a = c.toArray();
//        int numNew = a.length;
//        ensureCapacityHelper(elementCount + numNew);
//
//        int numMoved = elementCount - index;
//        if (numMoved > 0)
//        System.arraycopy(elementData, index, elementData, index + numNew, numMoved);
//
//        System.arraycopy(a, 0, elementData, index, numNew);
//        elementCount += numNew;
//        return numNew != 0;
//    }
//
//    // 返回两个对象是否相等
//    public synchronized boolean equals(Object o) {
//        return super.equals(o);
//    }
//
//    // 计算哈希值
//    public synchronized int hashCode() {
//        return super.hashCode();
//    }
//
//    // 调用父类的toString()
//    public synchronized String toString() {
//        return super.toString();
//    }
//
//    // 获取Vector中fromIndex(包括)到toIndex(不包括)的子集
//    public synchronized List<E> subList(int fromIndex, int toIndex) {
//        return Collections.synchronizedList(super.subList(fromIndex, toIndex), this);
//    }
//
//    // 删除Vector中fromIndex到toIndex的元素
//    protected synchronized void removeRange(int fromIndex, int toIndex) {
//        modCount++;
//        int numMoved = elementCount - toIndex;
//        System.arraycopy(elementData, toIndex, elementData, fromIndex,
//                         numMoved);
//
//        // Let gc do its work
//        int newElementCount = elementCount - (toIndex-fromIndex);
//        while (elementCount != newElementCount)
//            elementData[--elementCount] = null;
//    }
//
//    // java.io.Serializable的写入函数
//    private synchronized void writeObject(java.io.ObjectOutputStream s)
//        throws java.io.IOException {
//        s.defaultWriteObject();
//    }
//}
//总结：
//(01) Vector实际上是通过一个数组去保存数据的。当我们构造Vecotr时；若使用默认构造函数，则Vector的默认容量大小是10。
//(02) 当Vector容量不足以容纳全部元素时，Vector的容量会增加。若容量增加系数 >0，则将容量的值增加“容量增加系数”；否则，将容量大小增加一倍。
//(03) Vector的克隆函数，即是将全部元素克隆到一个数组中。

//《vector遍历方式》
//
//Vector支持4种遍历方式。建议使用下面的第二种去遍历Vector，因为效率问题。
//
//(01) 第一种，通过迭代器遍历。即通过Iterator去遍历。
//Integer value = null;
//Iterator<int> size = vec.iterator();
//while(size.hasNext()){
//	value = size.next();
//}
//
//(02) 第二种，随机访问，通过索引值去遍历。
//由于Vector实现了RandomAccess接口，它支持通过索引值去随机访问元素。
//
//Integer value = null;
//int size = vec.size();
//for (int i=0; i<size; i++) {
//    value = (Integer)vec.get(i);        
//}
//
//(03) 第三种，另一种for循环。如下：
//
//Integer value = null;
//for (Integer integ:vec) {
//    value = integ;
//}
//
//(04) 第四种，Enumeration遍历。如下：
//
//Integer value = null;
//Enumeration enu = vec.elements();
//while (enu.hasMoreElements()) {
//    value = (Integer)enu.nextElement();
//}
// 
//
//测试这些遍历方式效率的代码如下：
import java.util.Vector;
import java.util.List;
import java.util.Iterator;
import java.util.Enumeration;

/**
 * @desc Vector测试函数：遍历Vector和常用API 
 *
 * @author skywang
 */
public class 使用Vector {
    public static void main(String[] args) {
        // 新建Vector
        Vector<String> vec = new Vector<>();
            
        // 添加元素
        vec.add("1");
        vec.add("2");
        vec.add("3");
        vec.add("4");
        vec.add("5");

        // 设置第一个元素为100
        vec.set(0, "100");
        // 将“500”插入到第3个位置
        vec.add(2, "300");
        System.out.println("vec:"+vec);

        // (顺序查找)获取100的索引
        System.out.println("vec.indexOf(100):"+vec.indexOf("100"));
        // (倒序查找)获取100的索引
        System.out.println("vec.lastIndexOf(100):"+vec.lastIndexOf("100"));
        // 获取第一个元素
        System.out.println("vec.firstElement():"+vec.firstElement());
        // 获取第3个元素
        System.out.println("vec.elementAt(2):"+vec.elementAt(2));
        // 获取最后一个元素
        System.out.println("vec.lastElement():"+vec.lastElement());

        // 获取Vector的大小
        System.out.println("size:"+vec.size());
        // 获取Vector的总的容量
        System.out.println("capacity:"+vec.capacity());

        // 获取vector的“第2”到“第4”个元素
        System.out.println("vec 2 to 4:"+vec.subList(1, 4));

        // 通过Enumeration遍历Vector
        Enumeration<String> enu = vec.elements();
        while(enu.hasMoreElements())
            System.out.println("nextElement():"+enu.nextElement());
            
        Vector<String> retainVec = new Vector<>();
        retainVec.add("100");
        retainVec.add("300");
        // 获取“vec”中包含在“retainVec中的元素”的集合
        System.out.println("vec.retain():"+vec.retainAll(retainVec));
        System.out.println("vec:"+vec);
            
        // 获取vec对应的String数组
        String[] arr = (String[]) vec.toArray(new String[0]);
        for (String str:arr)
            System.out.println("str:"+str);

        // 清空Vector。clear()和removeAllElements()一样！
        vec.clear();
//        vec.removeAllElements();

        // 判断Vector是否为空
        System.out.println("vec.isEmpty():"+vec.isEmpty());
    }   
}

//总结：遍历Vector，使用索引的随机访问方式最快，使用迭代器最慢。


